--[[
    1.组件说明
        growable组件是一个管理实体生长阶段的组件，主要用于植物、作物等需要分阶段生长的物品
        但其实广义来说，所有带有阶段变化的东西都可以使用该组件达成，比如说皮弗娄牛，小牛是一个阶段，大牛又是另一个阶段
    2.组件属性
        基础属性：
            inst: 组件所属的实体对象
            stages: 生长阶段数据表（包含每个阶段的配置）
            stage: 当前生长阶段（从1开始）
            pausereasons: 暂停原因记录表（键值对形式）
        时间相关属性：
            targettime: 目标生长完成时间戳
            pausedremaining: 暂停时剩余的生长时间
            sleeptime: 实体进入睡眠状态的时间戳
            task: 生长任务句柄
        配置标志属性：
            loopstages: 是否循环生长阶段
            loopstages_start: 循环开始的阶段（默认为1）
            growonly: 是否只增长不设置阶段
            springgrowth: 是否应用春季生长加成
            growoffscreen: 是否在屏幕外也继续生长
            magicgrowable: 是否可以魔法生长
            usetimemultiplier: 是否使用时间倍数
        回调函数属性：
            domagicgrowthfn: 魔法生长回调函数
    3.组件方法：
        核心方法：
            StartGrowing(time): 开始生长
            StartGrowingTask(time): 启动生长任务
            StopGrowing(): 停止生长
            DoGrowth(skipgrownfn): 执行生长逻辑
            DoMagicGrowth(doer): 执行魔法生长
        阶段管理方法：
            GetStage(): 获取当前阶段
            GetNextStage(): 获取下一阶段（考虑循环）
            SetStage(stage): 设置当前阶段
            GetCurrentStageData(): 获取当前阶段数据
        暂停/恢复控制方法：
            Pause(reason): 暂停生长（支持多重暂停原因）
            Resume(reason): 恢复生长（移除指定暂停原因）
            IsPaused(): 检查是否处于暂停状态
        状态查询方法：
            IsGrowing(): 检查是否正在生长
            GetDebugString(): 获取调试信息字符串
        时间操作方法：
            ExtendGrowTime(extra_time): 延长生长时间
        生命周期方法：
            OnSave(): 保存组件状态
            OnLoad(data): 加载组件状态
            LongUpdate(dt): 长时间更新处理
            OnEntitySleep(): 实体睡眠处理
            OnEntityWake(): 实体唤醒处理
            OnRemoveFromEntity(): 从实体移除时的清理（指向StopGrowing）
    
    
    
    
    4.组件流程：
        1.组件初始化：
            创建 Growable 实例 → 初始化基础属性
            ├── self.inst = inst (绑定实体)
            ├── self.stages = nil (等待外部设置)
            ├── self.stage = 1 (初始阶段)
            ├── self.pausereasons = {} (暂停原因表)
            └── 其他可选属性保持默认值
        
        2.配置阶段（外部调用），即通过外部代码设置组件属性
            ├── 设置 self.stages (阶段数据表)
            ├── 设置可选标志：
            │   ├── self.loopstages (是否循环)
            │   ├── self.loopstages_start (循环起始点)
            │   ├── self.growonly (只增长不设置阶段)
            │   ├── self.springgrowth (春季加成)
            │   ├── self.growoffscreen (屏幕外生长)
            │   ├── self.magicgrowable (魔法生长)
            │   └── self.usetimemultiplier (使用时间倍数)
            └── 设置回调函数 self.domagicgrowthfn

        3.开始生长流程
            外部代码调用 StartGrowing(time)开始实体的生长
            ├── 设置 self.usetimemultiplier = false
            ├── 检查 #self.stages == 0 (阶段表是否为空)
            ├── 检查 self.stage > #self.stages (是否超出阶段)
            ├── 调用 StopGrowing() (清理之前的生长状态)
            │   ├── 设置 self.targettime = nil
            │   ├── 设置 self.pausedremaining = nil
            │   └── 取消并清理 self.task
            ├── 计算生长时间：
            │   ├── 如果 time == nil：
            │   │   ├── 调用 GetCurrentStageData() 获取当前阶段数据
            │   │   ├── 从阶段数据获取 timefn
            │   │   ├── 调用 timefn(self.inst, self.stage, stagedata) 或使用 FALLBACK_GROWTH_TIME
            │   │   └── 设置 self.usetimemultiplier = stagedata.multiplier
            │   └── 如果设置了 self.springgrowth，调用 SpringGrowthMod(time)
            └── 调用 StartGrowingTask(time)
                ├── 设置 self.targettime = GetTime() + time
                ├── 检查 self.growoffscreen 或 not self.inst:IsAsleep()
                ├── 取消现有 self.task
                └── 创建新的 self.task = self.inst:DoTaskInTime(time, OnGrow, self)
        
        4.生长执行流程
            定时器触发 OnGrow(inst, self)
            ├── 设置 self.task = nil
            └── 调用 DoGrowth()
                ├── 检查生长状态 (self.targettime 和 self.pausedremaining)
                ├── 调用 GetNextStage() 计算下一阶段
                │   ├── 计算 stage = self.stage + 1
                │   ├── 如果 stage <= #self.stages，返回 stage
                │   └── 否则根据 self.loopstages 返回循环起始点或最后阶段
                ├── 获取下一阶段数据 self.stages[stage]
                ├── 执行预生长回调 stagedata.pregrowfn(self.inst, stage, stagedata)
                ├── 如果不是 self.growonly，调用 SetStage(stage)
                │   ├── 限制 stage <= #self.stages
                │   ├── 设置 self.stage = stage
                │   └── 执行阶段回调 stagedata.fn(self.inst, stage, stagedata)
                ├── 执行生长回调 stagedata.growfn(self.inst, stage, stagedata)
                ├── 判断是否继续生长：
                │   ├── 如果 (self.stage < #self.stages) 或 self.loopstages
                │   ├── 调用 StartGrowing() (递归开始下一阶段)
                │   └── 否则调用 StopGrowing()
                └── 返回 true
        
        5.暂停/恢复流程
            暂停流程 Pause(reason)
            ├── 如果 self.pausedremaining == nil (首次暂停)：
            │   ├── 如果 self.sleeptime ~= nil，先调用 LongUpdate(dt) 追赶时间
            │   ├── 记录 targettime = self.targettime
            │   ├── 调用 StopGrowing() 停止生长
            │   └── 计算 self.pausedremaining = targettime - GetTime()
            └── 记录暂停原因 self.pausereasons[reason] = true

            恢复流程 Resume(reason)
            ├── 移除暂停原因 self.pausereasons[reason] = nil
            ├── 检查是否还有其他暂停原因 next(self.pausereasons) ~= nil
            ├── 如果没有暂停原因且 self.pausedremaining ~= nil：
            │   ├── 调用 StartGrowingTask(self.pausedremaining)
            │   ├── 设置 self.pausedremaining = nil
            │   └── 返回 true

        6.实体睡眠/唤醒流程
            睡眠流程 OnEntitySleep()
            ├── 检查 self.task == nil 或 self.growoffscreen
            ├── 取消 self.task
            ├── 设置 self.task = nil
            └── 记录 self.sleeptime = GetTime()

            唤醒流程 OnEntityWake()
            ├── 检查 self.targettime == nil 或 self.growoffscreen
            ├── 如果 self.sleeptime ~= nil：
            │   ├── 计算 dt = GetTime() - self.sleeptime
            │   ├── 设置 self.sleeptime = nil
            │   └── 调用 LongUpdate(dt) 追赶睡眠期间的时间
            └── 否则使用旧代码逻辑直接处理

        7. 长时间更新流程（比较典型的比如T键一次性跳过多少天）
            LongUpdate(dt) 
            ├── 检查 self:IsGrowing() (self.targettime ~= nil)
            ├── 如果 self.sleeptime ~= nil，减少睡眠时间并返回
            ├── 记录 currentstage = self.stage
            ├── 循环处理时间差：
            │   ├── 计算 timeleft = self.targettime - GetTime()
            │   ├── 如果 (timeleft - dt) > 0，调用 StartGrowingTask(timeleft - dt)
            │   ├── 否则：
            │   │   ├── 减少 dt
            │   │   ├── 调用 DoGrowth(true) 跳过 growfn
            │   │   └── 如果 self.growonly，增加 currentstage
            ├── 如果阶段发生变化，执行最终的 growfn 回调

        8.魔法生长流程
            外部调用 DoMagicGrowth(doer)
            ├── 如果设置了 self.domagicgrowthfn，调用该函数
            └── 返回该函数的返回值

        9. 时间扩展流程
            外部调用 ExtendGrowTime(extra_time)
            ├── 如果 self.pausedremaining ~= nil，增加暂停剩余时间
            └── 否则如果正在生长，重新计算并启动生长任务

        10.数据持久化（就是常规说的保存加载）
            保存流程 OnSave()
            ├── 计算当前剩余时间
            ├── 如果使用时间倍数，除以 GetStageTimeMultiplier(self)
            ├── 返回包含 stage、time、usetimemultiplier 的数据表

            加载流程 OnLoad(data)
            ├── 调用 SetStage(data.stage or 1)
            ├── 如果有时间数据：
            │   ├── 如果使用时间倍数，乘以 GetStageTimeMultiplier(self)
            │   └── 调用 StartGrowing(data.time)

        11.状态查询和调试
            状态查询方法：
            ├── IsGrowing() - 检查 self.targettime ~= nil
            ├── IsPaused() - 检查 self.pausedremaining ~= nil
            ├── GetStage() - 返回 self.stage
            └── GetDebugString() - 返回详细的调试信息字符串

        12.组件清理流程
            OnRemoveFromEntity (指向 StopGrowing)
            ├── 设置 self.targettime = nil
            ├── 设置 self.pausedremaining = nil
            └── 取消并清理 self.task
]]




--[[

    如果你是新人，渴望更多更轮椅的了解的话，看看下面这些内容吧，老人基本上上面的解释就够用了
    备注：以下内容都是ai跑的，clude4pous，流量很贵，时间限制我也没有办法一个一个挨个验证，所以细节方面可能会有些许问题
    但是至少每段代码我都是读过的，尽量保证准确性
    ps：错了你也不能拿我怎么样，嘻嘻

    1.属性详解：
        1.inst：这个就不说了，就是组件所属的实体对象，写mod不至于这个都不知道。
        2.stages，成长阶段数据表，这个表是组件的核心，基本上后续所有的内容都是围绕着这个表来展开的。
                    默认是nil，但是你要知道的是只有正常设置了stages，才能保证组件正常工作。
                    它是一个数组，存储所有成长阶段的配置数据。每个阶段可以包含时间函数、成长函数、预成长函数等
                    具体结构：
                        { --有几个阶段就写几次子表，每个子表单独配置
                            name:string,必选，标识该阶段的名称
                            time：number或fn，时间函数，必选，该阶段的生长时间。一般只有农作物是将time作为函数设置
                                [
                                    参数：
                                        inst：可选，当前实例对象，即拥有growable组件的实体
                                        stage：可选，number， 当前阶段的索引 (不是即将进入的阶段)
                                        stage_data：可选，table，: 当前阶段的完整配置数据
                                ]
                            multiplier：number，可选，time的修饰符，乘法。比如time函数返回10s，当修饰符为3的时候，实际生长时间是30s
                            fn：function，必选，阶段设置函数，当通过SetStage(stage)设置阶段时立即调用，设置的内容是当前阶段的内容,或者说是进入当前阶段的时候执行的内容
                                [
                                    参数：
                                        inst：可选，当前实例对象，即拥有growable组件的实体
                                        stage：可选，number， 当前阶段的索引 (不是即将进入的阶段)
                                        stage_data：可选，table，: 当前阶段的完整配置数据
                                ]
                            growfn：function，可选，阶段生长函数，在DoGrowth()执行时，生长到该阶段后调用
                                [
                                    参数：
                                        inst：可选，当前实例对象，即拥有growable组件的实体
                                        stage：可选，number， 当前阶段的索引 (不是即将进入的阶段)
                                        stage_data：可选，table，: 当前阶段的完整配置数据
                                    与fn的区别：
                                        fn主要是设置阶段状态（静态配置），每次进入该阶段都会执行，例如存档加载的时候等等，一般写该阶段长期需要保存的内容
                                        growfn则是处理生长过程（动态效果），只在实际成长时执行一次，处理成长过程的动态效果，比如播放1形态到2形态的成长动画
                                ]
                            pregrowfn：function，可选，阶段生长前函数，在DoGrowth()开始时，进入新阶段之前调用
                                [
                                    参数：
                                        inst：可选，当前实例对象，即拥有growable组件的实体
                                        stage：可选，number， 即将生长到的阶段索引
                                        stage_data：可选，table，即将进入阶段的配置数据
                                    备注：
                                        在生长前进行准备工作，如检查条件、消耗资源、设置标记等
                                        调用顺序: pregrowfn → SetStage(调用fn) → growfn
                                ]
                        }
        3. stage： number (整数)， 表示当前处于第几个成长阶段。它是stages数组的索引值，从1开始计算。
                    默认为1，不过是自动管理，通常不需要手动设置
    

        以下四个属于时间管理系统，正常成长时： targettime 和 task 工作，其他两个为 nil。
                                暂停时： pausedremaining 保存剩余时间，targettime 和 task 被清除
                                休眠时： sleeptime 记录时间戳，task 被取消但 targettime 保留
                                恢复时： 根据具体情况恢复相应的属性值
        4.pausereasons：table表，存储导致成长暂停的各种原因。
                        它是一个以原因名称为键、true为值的表。
                        只有当所有原因都被移除时，成长才会恢复。
                        每当使用类似于Pause("winter")的方式添加暂停原因时，会将winter = true存入表中，而使用Resume("winter")时，会将表中的winter移除，只有这个表位空时，才会继续成长
                        这个表的好处就是可以通过多个原因来暂停生长。

        5.targettime：number或nil，由组件自动管理，一般不手动设置
                    存储成长任务预计完成的绝对时间戳。
                    当成长开始时，被设置为GetTime() + 成长时间，用于计算剩余成长时间。

        6.pausedremaining：number或nil，由组件自动管理，一般不手动设置
                            存储成长被暂停时剩余的成长时间。
                            当暂停时，系统会计算还需要多少时间才能完成成长，并保存这个值，恢复时使用这个时间重新开始成长。
    
        7.sleeptime：number或nil，由组件自动管理，一般不手动设置
                    记录实体进入休眠状态时的时间戳。
                    当实体离开玩家视野休眠时，成长任务会被取消，但系统会记录休眠开始的时间。
                    当实体重新激活时，会计算休眠期间流逝的时间并快速完成应有的成长。
        8.task ： Task对象 或 nil，由组件自动管理，一般不手动设置
                    task存储当前活跃的成长定时任务的引用
                    通过这个引用可以取消正在进行的成长任务。


        以下7个即加入组件时官方建议你配置的部分：
        9.loopstages ：boolean，可选
                    loopstages 控制植物是否在达到最后阶段后循环回到某个阶段重新开始成长。
                    一旦设置，植物不会停在最终阶段，而是会循环成长。

        10.loopstages_start：number，可选
                            配合上面的loopstages使用，用于设置达到最后阶段后具体循环回到哪个阶段新开始成长
                            启用循环生长的情况下，如果不设置该属性，默认从第1阶段开始。
        
        11.growonly：boolean，可选
                    控制成长时是否只执行成长逻辑而不改变实际的阶段
                    什么意思呢？就是如果设置了该属性，那么成长的时候会跳过SetStage这个环节，转而执行剩下的pregrownfb等其他函数
                    类比场景：需要多次浇水才能真正成长的植物，每次浇水触发一次"成长"，但不改变外观，直到满足某些条件后才真正进入下一阶段
            
        12.springgrowth：boolean，可选
                        启用春季成长加速机制。
                        启用后，植物在春季的成长时间会被TUNING.SPRING_GROWTH_MODIFIER修改（这是一个修饰符，与原版时间是乘法关系）

        13.growoffscreen ：boolean，可选
                        控制植物是否可以在离开玩家视野时继续成长
                        默认情况下，离屏的实体会进入休眠状态，成长会暂停。
                        众所周知，休眠下的实体再次唤醒时系统会进行相应的睡眠补偿，那为什么会有这个属性呢？
                        首先，休眠补偿是在实体重新进入玩家加载范围时进行的，如果存在多个实体，短时间会消耗掉系统大量的计算资源
                        其次，如果你的成长逻辑很复杂，补偿机制可能会漏掉某些内容，导致出现问题
                        而该属性则是离屏实时成长，成长按实际时间自然发生，不需要复杂的补偿计算，并且保证生长逻辑正常执行。
                        当然，坏处也显而易见，实体离开加载范围休眠本来就是系统为了游戏流程而进行的优化，当大量设置了该属性的物体存在世界上时，游戏会不可避免的卡顿。
                        因此，只建议对重点物品设置该属性，最好是具有唯一性
        
        14.magicgrowable ：boolean，可选
                        标记植物是否可以被魔法道具（奶奶的书等）快速催熟
                        这是一个标识属性，具体的魔法成长逻辑需要配合其他系统。
        
        15.usetimemultiplier ：boolean，一般不需要手动设置，由系统自动管理
                            控制在保存/加载游戏时是否应用阶段时间倍数修正
                            需要配合stages的multiplier键，确保加载游戏时，时间倍数被正确应用

        16.domagicgrowthfn:function，可选,当植物受到魔法效果（如园艺书籍、生长法杖等）影响时被调用，用于定义特殊的生长行为。
                            参数：
                                inst：实体，必选，无默认值，拥有growable组件的实体
                                doer：实体，可选，无默认值，魔法道具的施法者
                            返回值：
                                boolean 或 nil,通常返回 true 表示成功，false 或 nil 表示失败，表示魔法生长是否成功执行



    函数详解：
        1.StartGrowing(time)：
            作用：
                启动实体的生长过程，一般在prefab添加配置完组建后都需要调用一次该函数，除非你希望你的prefab生成出来的时候默认不成长
            参数：
                time：number，可选，生长时间，单位为秒，如果不传，则会stage中的time相关内容计算生长到下一个阶段的时间
            返回值：
                nil
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.重置 usetimemultiplier 为 false
                2.调用 StopGrowing() 停止当前生长
                3.根据是否提供time参数决定本次生长到下一阶段的时间，单位是秒。
                    注意：
                        如果是未提供参数，则自动计算
                        先获取当前阶段数据，如果有时间函数，调用它获取时间，否则使用默认时间10s，之后根据配置设置是否使用时间倍数器
                        此外，传入的时间仅作用于本次生长到下一阶段的过程，因为组件默认后续重新开始下阶段循环的时候是没有传递参数的，因此后续的时间还是依据配置中的设置为准
                4.如果启用了春天生长加速springgrowth，应用 SpringGrowthMod 函数传入第三步得到的时间，计算最终时间
                5.最终通过StartGrowingTask开始实际的生长任务

        2.StartGrowingTask(time)
            作用：
                创建定时任务来处理生长，一般不手动调用，由StartGrowing内部调用
            参数：
                time：number，必选，无默认值生长时间，函数内部会对参数进行处理，限制time不小于0，单位为秒
            返回值：
                nil
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.内部处理参数，确保时间不小于0
                2.设置 targettime属性（当前时间加上生长时间）
                3.当允许离屏生长或实体未休眠时，先取消当前task（如果有），然后创建新的定时任务，时间到后调用 OnGrow 函数
            备注：
                与StartGrowing的区别在于，本函数只负责设定定时器，是纯粹的任务调度。
                而StartGrowing还包含了一系列时间计算等逻辑。
        
        3.StopGrowing()
            作用：
                停止当前的生长过程，清除所有相关的状态和任务。
            参数：
                nil
            返回值：
                nil
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.清除 targettime
                2.清除 pausedremaining
                3.取消当前task（如果有）
                
        4.DoGrowth(skipgrownfn)
            作用：
                执行实际的生长操作，使物品进入下一个生长阶段。这是生长的核心逻辑。
            参数：
                skipgrownfn：boolean，可选，默认为false，是否跳过growfn的调用，主要用于批量更新时避免重复调用
            返回值：
                bool，true 表示成功生长，false 表示没有生长或已停止
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.检查是否处于生长或暂停状态，都没有则返回 false
                2.获取下一个生长阶段和阶段数据
                3.如果存在预生长函数（pregrowfn），先执行它
                4.如果不是只生长模式（growonly为nil），设置新阶段
                5.实体有效的情况下，如果不跳过growfn且有growfn，执行它；如果未达到最大阶段或支持循环（loopstages），继续下一次生长；否则停止生长

        5.DoMagicGrowth(doer)
            作用：
                执行魔法生长逻辑，通常用于法术书籍、魔法道具等的快速生长效果。
            参数：
                doer：实体，可选，无默认值，魔法道具的施法者
            返回值：
                取决于 domagicgrowthfn 函数的返回值，如果没设置该函数则返回 nil
            注意：
                不同于DoGrowth函数，DoMagicGrowth完全依赖于domagicgrowthfn属性，需要自己在该函数中写状态切换等等
        
        6.GetStage()
            作用：
                获取当前生长阶段的索引号。这是最基础的状态查询方法，用于了解物品当前处于哪个生长阶段。
            参数：
                无
            返回值：
                number，返回的是stage 属性，即当前生长阶段对应的索引（从1开始计数），无默认返回值

        7.GetNextStage
            作用：
                获取下一个生长阶段的索引号。这个方法考虑了循环生长的情况，是生长逻辑的关键部分。
            参数：
                无
            返回值：
                number，返回的是下一个阶段的索引，无默认返回值
            备注：
                如果未设置循环生长，返回当前阶段+1；如果启用循环且到目前是最后阶段，返回循环起始点

        8.SetStage(stage)
            作用：
                设置当前生长阶段，并执行该阶段对应的函数。这是直接控制生长状态的核心方法。
            参数：
                stage：number，必选，无默认值，要设置的阶段索引（从1开始计数）
            返回值：
                nil
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.检查传入的阶段是否超过最大阶段数，如果超过则限制为最大值
                2.设置 self.stage = stage
                3.获取该阶段的数据 stagedata = self.stages[stage]
                4.如果阶段数据存在且有执行函数（stagedata.fn），调用该函数

        9. GetCurrentStageData()
            作用：
                获取当前阶段的完整数据表。这个方法返回当前阶段的所有配置信息，包括时间函数、执行函数等。
            参数：
                无
            返回值：
                table或nil，当前生长阶段的完整配置数据，无默认返回值

        10.Pause(reason)
            作用：
                暂停生长过程，支持多重暂停原因的管理。当有任何暂停原因存在时，生长都会停止。
            参数：
                string，可选，无默认值，用作暂停的原因标识符，用于管理多个暂停条件
            返回值：
                无
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.首先确认是否处于暂停状态（pausereasons不为空），如果处于暂停状态，则将参数作为原因添加到pausereasons表中
                2.如果未处于暂停状态，则获取当前时间，如果有睡眠时间，先进行追赶更新（LongUpdate），之后停止当前生长并保存剩余时间到 pausedremaining

        11. Resume(reason)
            作用：
                恢复生长过程，移除特定的暂停原因。只有当所有暂停原因都被移除后，生长才会真正恢复。
            参数：
                string，可选，无默认值，要移除的暂停原因标识符
            返回值：
                boolean或nil，如果成功恢复生长返回 true，否则返回 nil
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.如果提供了参数，从 pausereasons 表中移除该原因
                2.检查pausereasons是否为空
                3.如果为空，且有暂停剩余时间pausedremaining，则使用剩余时间重新作为参数调用StartGrowingTask，之后清除pausedremaining并返回true
                
        12.IsPaused()
            作用：
                检查生长是否处于暂停状态
            参数：
                无
            返回值：
                boolean，根据pausedremaining来返回true或者false来表示是否处于暂停状态
          
        13.IsGrowing()
            作用：
                检查是否正在生长
            参数：
                无
            返回值：
                boolean，根据targettime来返回true或者false来表示是否处于暂停状态

        14.GetDebugString()
            作用：
                获取用于调试的状态信息字符串
            参数：
                无
            返回值：
                string，包含当前生长状态的详细信息字符串
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.计算睡眠时间sleeptime偏移
                2.根据不同状态返回相应的调试信息,如果暂停显示当前阶段和暂停剩余时间;如果生长显示当前阶段和剩余时间,否则显示"Not Growing"

        15.ExtendGrowTime(time)
            作用：
                延长当前的生长时间。这个方法用于动态调整生长进度
            参数：
                time：number，必选，无默认值，要延长的生长时间，单位为秒，可以是负数表示减少生长时间
            返回值：
                nil
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.如果处于暂停状态（pausedremaining 不为 nil），直接增加暂停剩余时间
                2.如果正在生长（IsGrowing() 为 true），计算新的剩余时间并重新开始生长任务

        16.OnSave()
            作用：
                将组件的当前状态保存到数据表中，用于游戏存档
            参数：
                time：number，必选，无默认值，要延长的生长时间，单位为秒，可以是负数表示减少生长时间
            返回值：
                table 或 nil，包含需要保存的数据，如果没有数据需要保存则返回 nil，类似于return {xxx =self.xxx}
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.计算当前剩余生长时间,如果暂停：使用 pausedremaining;如果生长中：计算 targettime - GetTime();都不是则为 nil
                2.确保时间不为负数
                3.如果使用时间倍数器，将时间除以倍数器值（保存基础时间）
                4.保存内容为当前阶段索引stage、剩余时间time、是否使用时间倍数器usetimemultiplier
        
        17.OnLoad(data)
            作用：
                从保存的数据中恢复组件状态，确保生长进度在游戏加载后正确继续。
            参数：
                table 类型，可选参数，无默认值,如果你用onsave保存过数据，那么这的data参数就是当时保存的那张表
            返回值：
                无
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.检查数据是否存在，不存在则返回
                2.设置阶段（默认为1）
                3.如果有时间数据,且使用时间倍数器，将时间乘以当前倍数器值，否则使用恢复的时间重新开始生长
        
        18.LongUpdate(dt)
            作用：
                处理长时间的更新，通常在实体从睡眠状态唤醒时调用，用来快速计算实体休眠这段时间发生的改变
            参数：
                number 类型，必需参数，无默认值,表示需要更新的时间间隔（秒），即从休眠到唤醒这段的时间
            返回值：
                无
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.检查是否正在生长，不是则返回
                2.如果有睡眠时间记录，减去dt并返回
                3.进入生长推进循环:
                    计算到下次生长完成的剩余时间
                    如果dt不足以完成当前生长，调整任务时间并结束
                    否则推进生长，更新dt，继续循环
                4.处理 growonly 模式的特殊情况
                5.如果阶段发生变化，执行对应的生长函数

        16.OnEntitySleep()
            作用：
                当实体进入睡眠状态时调用。对于不支持离屏生长的植物，这个方法会暂停生长任务并记录睡眠时间。
            参数：
                无参数
            返回值：
                无返回值
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.检查是否有生长任务或支持离屏生长，都没有则返回
                2.取消当前生长任务
                3.记录并设置进入睡眠的时间

        17.OnEntityWake()
            作用：
                当实体从睡眠状态唤醒时调用。这个方法会恢复生长任务或进行长时间更新以追赶睡眠期间应该发生的生长。
            参数：
                无参数
            返回值：
                无返回值
            函数关键点（非完整执行流程，按执行顺序排序）：
                1.检查是否有目标时间或支持离屏生长，都没有则返回
                2.如果有睡眠时间记录,则计算睡眠持续时间,调用 LongUpdate 追赶生长
                3.否则检查是否应该立即生长,然后重新启动生长任务

        18.OnRemoveFromEntity()
            作用：
                当组件从实体中被移除时调用。这个方法确保清理所有相关资源，避免内存泄漏。
            参数：
                无参数
            返回值：
                无返回值
            函数关键点（非完整执行流程，按执行顺序排序）：
                实际就是StopGrowing的别名，组件采用的是直接赋值Growable.OnRemoveFromEntity = Growable.StopGrowing
]]
















